# -*- coding: utf-8 -*-
import math
import mod.client.extraClientApi as clientApi
from mod.client.ui.controls.baseUIControl import BaseUIControl
from legendaryPowerClientScript.ui.base.buttonComponent import ButtonComponent
from legendaryPowerClientScript.ui.base.imageComponent import ImageComponent
from legendaryPowerClientScript.ui.base.itemComponent import ItemComponent
from legendaryPowerClientScript.ui.base.itemRendererComponent import ItemRendererComponent
from legendaryPowerClientScript.ui.base.labelComponent import LabelComponent
from legendaryPowerClientScript.ui.base.listComponent import ListComponent
from legendaryPowerClientScript.ui.base.progressBarComponent import ProgressBarComponent
from legendaryPowerClientScript.ui.base.selectAmountComponent import SelectAmountComponent
from legendaryPowerClientScript.ui.base.sliderBarComponent import SliderComponent
from legendaryPowerClientScript.ui.base.toggleComponent import ToggleComponent
from legendaryPowerClientScript.util import apiUtil
class BaseComponent():
    # type: () -> None
    """
    BaseComponent类是UI组件的基础类，封装了UI组件的一些基本属性和方法。

    Attributes:
        _path (str): 组件在UI中的路径
        _ui (UIBase): 操作的UI对象
        _component (BaseUIControl): 组件对应的UI控件
        _children (dict): 子组件对象字典
        _typeHint (str): 组件类型提示，用于校验子组件类型
        _typeHints (list of str): 子组件类型提示列表
        isDummy (bool): 是否为虚拟组件
        _alpha (float): 组件透明度，取值范围[0,1]
        tweenAnimation (list of Tween): 缓动动画列表
        tweenTask (Task): 缓动动画任务
        layer (int): 组件的渲染层级
        _registeredChildren (bool): 是否已注册子组件
        posOffset (tuple): 相对位置偏移量，格式为(x,y)
        disableAddTweenTime (float): 禁止添加缓动的时间，单位为秒
        definedPos (tuple): 手动定义的位置，格式为(x,y)
        defaultPos (tuple): 组件的默认位置，格式为(x,y)
    """
    self._path  = ""
    self._ui  = UIBase()
    self._component  = BaseUIControl()
    self._children  = {}
    self._typeHint  = ""
    self._typeHints  = ""
    self.isDummy  = False
    self._alpha  = 0.0
    self.tweenAnimation  = []
    self.tweenTask  = Task()
    self.layer  = 0
    self._registeredChildren  = False
    self.posOffset  = ()
    self.disableAddTweenTime  = 0.0
    self.definedPos  = ()
    self.defaultPos  = ()

    def registerChildrenRecursively(self):
        """
        递归注册所有子组件
        """
        pass

    def SetAlpha(self, alpha, recursive=False):
        # type: (float, bool) -> None
        """
        设置组件的透明度

        Args:
        - alpha (float): 透明度值，取值范围[0, 1]
        - recursive (bool): 是否递归设置子组件的透明度，只会影响已注册的子组件（registerChildrenRecursively(), getXXX() 等方式均可自动注册）
        """
        pass

    def resetTween(self):
        # type: () -> None
        """
        清除绑定的UI动画
        """
        pass

    def addTween(self, tween):
        # type: (Tween) -> None
        """
        添加UI动画

        Args:
        - tween (Tween): 缓动动画对象
        """
        pass

    def _tickTween(self):
        # type: () -> None
        """
        执行缓动动画
        """
        pass

    def GetChild(self, path, typeHint=None, param=None):
        # type: (str) -> BaseComponent
        """
        获取子组件对象

        Args:
        - path (str): 子组件在当前组件中的路径
        - typeHint (str): 子组件类型提示，可用的有 Base Button Image Label List Slider Item ItemRenderer Toggle SelectAmount Progressbar Textbox
        - param: 参数

        Returns:
          BaseComponent: 子组件对象
        """
        pass

    def getComponent(self, path):
        # type: (str) -> BaseComponent
        """
        获取指定路径下的组件对象

        Args:
        - path (str): 组件在当前组件中的路径

        Returns:
          BaseComponent: 组件对象
        """
        pass

    def getImage(self, path):
        # type: (str) -> ImageComponent
        """
        获取指定路径下的图片组件对象

        Args:
        - path (str): 图片组件在当前组件中的路径

        Returns:
        - ImageComponent: 图片组件对象
        """
        pass

    def getButton(self, path):
        # type: (str) -> ButtonComponent
        """
        获取指定路径下的按钮组件对象

        Args:
        - path (str): 按钮组件在当前组件中的路径

        Returns:
        - ButtonComponent: 按钮组件对象
        """
        pass

    def getLabel(self, path):
        # type: (str) -> LabelComponent
        """
        获取指定路径下的文本组件对象

        Args:
        - path (str): 文本组件在当前组件中的路径

        Returns:
        - LabelComponent: 文本组件对象
        """
        pass

    def getPanel(self, path):
        # type: (str) -> BaseComponent
        """
        获取指定路径下的面板组件对象

        Args:
        - path (str): 面板组件在当前组件中的路径

        Returns:
          BaseComponent: 面板组件对象
        """
        pass

    def getSelectAmount(self, path):
        # type: (str) -> SelectAmountComponent
        """
        获取指定路径下的选择数量组件对象

        Args:
        - path (str): 选择数量组件在当前组件中的路径

        Returns:
        - SelectAmountComponent: 选择数量组件对象
        """
        pass

    def getToggle(self, path):
        # type: (str) -> ToggleComponent
        """
        获取指定路径下的开关组件对象

        Args:
        - path (str): 开关组件在当前组件中的路径

        Returns:
        - ToggleComponent: 开关组件对象
        """
        pass

    def getList(self, path, param=None):
        # type: (str) -> ListComponent
        """
        获取指定路径下的列表组件对象

        Args:
        - path (str): 列表组件在当前组件中的路径
        - param: 参数

        Returns:
        - ListComponent: 列表组件对象
        """
        pass

    def getItem(self, path, param=None):
        # type: (str) -> ItemComponent
        """
        获取指定路径下的项组件对象

        Args:
        - path (str): 项组件在当前组件中的路径
        - param: 参数

        Returns:
        - ItemComponent: 项组件对象
        """
        pass

    def getItemRenderer(self, path):
        # type: (str) -> ItemRendererComponent
        """
        获取指定路径下的项渲染器组件对象

        Args:
        - path (str): 项渲染器组件在当前组件中路径

        Returns:
        - ItemRendererComponent: 项渲染器组件对象
        """
        pass

    def getSlider(self, path):
        # type: (str) -> SliderComponent
        """
        获取指定路径下的滑动条组件对象

        Args:
        - path (str): 滑动条组件在当前组件中的路径

        Returns:
        - SliderBarComponent: 滑动条组件对象
        """
        pass

    def getProgressbar(self, path):
        # type: (str) -> ProgressBarComponent
        """
        获取指定路径下的进度条组件对象

        Args:
        - path (str): 进度条组件在当前组件中的路径

        Returns:
        - ProgressBarComponent: 进度条组件对象
        """
        pass

    def __getitem__(self, item):
        # type: (str) -> BaseComponent
        """
        获取指定路径下的子组件对象

        Args:
        - item (str): 子组件在当前组件中的路径

        Returns:
          BaseComponent: 子组件对象
        """
        return BaseComponent()


    def SetVisible(self, visible):
        # type: (bool) -> None
        """
        设置组件的可见性

        Args:
        - visible (bool): 是否可见
        """
        pass

    def SetLayer(self, layer):
        # type: (int) -> None
        """
        设置组件的层级

        Args:
        - layer (int): 层级值
        """
        pass

    def __bool__(self):
        # type: () -> bool
        """
        判断组件是否有效

        Returns:
          bool: 组件是否有效
        """
        return False


    def GetSize(self):
        # type: () -> - tuple
        """
        获取组件的大小

        Returns:
        - tuple: 组件的大小
        """
        return ()


    def SetSize(self, size, resize=False):
        # type: (tuple, bool) -> None
        """
        设置组件的大小

        Args:
        - size (tuple): 组件的大小，格式为(width, height)
        - resize (bool): 是否重置大小
        """
        pass

    def GetDefaultPos(self):
        # type: () -> - tuple
        """
        获取组件的默认位置

        Returns:
        - tuple: 组件的默认位置，格式为(x, y)
        """
        return ()


    def GetPosition(self):
        # type: () -> - tuple
        """
        获取组件的位置

        Returns:
        - tuple: 组件的位置，格式为(x, y)
        """
        return ()


    def SetPosition(self, pos):
        # type: (tuple) -> None
        """
        设置组件的位置

        Args:
        - pos (tuple): 组件的位置，格式为(x, y)
        """
        pass

class Tween:
    # type: () -> None
    """
    一个用于创建动画效果的类。

    Attributes:
        component (BaseComponent): 应用效果的组件。
        duration (int): 效果的持续时间（以帧为单位）。
        elapsedTick (int): 已经过去的帧数。
        nextTween (Tween): 下一个要应用的Tween效果。
        endCallback (callable): 当效果结束时调用的回调函数。没有参数。
        linear (bool): 动画速度匀速。 False时：动画速度是一开始很快，后面慢慢的
        sine (bool): 是否使用正弦波效果，默认为False。
    """
    self.component  = BaseComponent()
    self.duration  = 0
    self.elapsedTick  = 0
    self.nextTween  = Tween()
    self.endCallback  = None # callable
    self.linear  = False
    self.sine  = False

    def __init__(self, durationTick, linear=True, sine=False):
        # type: (int, bool, 可选, bool, 可选) -> None
        """
        初始化Tween类的新实例。

        Args:
            durationTick (int): 效果的持续时间（以帧为单位）。
            linear (bool, 可选): True时：动画速度匀速。 False时：动画速度是一开始很快，后面慢慢的
            sine (bool, 可选): 是否使用正弦波效果，默认为False。
        """
        pass

    def groupWith(self, tween):
        # type: (Tween) -> None
        """
        将当前效果与另一个效果进行组合，令其同时生效。

        Args:
            tween (Tween): 要分组的效果。
        """
        pass

class StasisTween(Tween):
    # type: () -> None
    """
    Tween的子类，持续时间内组件保持静止。主要用于等待一段时间后播放其它的动画

    Attributes:
        durationTick (int): 效果的持续时间（以帧为单位）。
    """
    self.durationTick  = 0

class AlphaChangeTween(Tween):
    # type: () -> None
    """
    Tween的子类，实现透明度变化的动画效果。

    Attributes:
        startAlpha (float): 起始透明度。
        endAlpha (float): 目标透明度。
        recursive (bool): 是否递归应用到子组件。
        autoSetInvisible (bool): 动画结束后是否自动设置为不可见。
    """
    self.startAlpha  = 0.0
    self.endAlpha  = 0.0
    self.recursive  = False
    self.autoSetInvisible  = False

    def __init__(self, startAlpha, endAlpha, durationTick, recursive=True, linear=False, autoSetInvisible=False):
        # type: (float, float, int, bool, 可选, bool, bool, 可选) -> None
        """
        初始化AlphaChangeTween类的新实例。

        Args:
            startAlpha (float): 起始透明度。
            endAlpha (float): 目标透明度。
            durationTick (int): 效果的持续时间（以帧为单位）。
            recursive (bool, 可选): 是否递归应用到子组件，默认为True。
            linear (bool): 动画速度匀速。 False时：动画速度是一开始很快，后面慢慢的
            autoSetInvisible (bool, 可选): 动画结束后是否自动设置为不可见，默认为False。
        """
        pass

class ColorChangeTween(Tween):
    # type: () -> None
    """
    Tween的子类，实现颜色变化的动画效果。

    Attributes:
        startColor (tuple): 起始颜色（RGB元组）。
        endColor (tuple): 目标颜色（RGB元组）。
    """
    self.startColor  = ()
    self.endColor  = ()

    def __init__(self, startColor, endColor, durationTick, linear=False):
        # type: (tuple, tuple, int, bool) -> None
        """
        初始化ColorChangeTween类的新实例。

        Args:
            startColor (tuple): 起始颜色（RGB元组）。
            endColor (tuple): 目标颜色（RGB元组）。
            durationTick (int): 效果的持续时间（以帧为单位）。
            linear (bool): 动画速度匀速。 False时：动画速度是一开始很快，后面慢慢的
        """
        pass

class FontSizeChangeTween(Tween):
    # type: () -> None
    """
    Tween的子类，实现字体大小变化的动画效果。

    Attributes:
        startFont (int): 起始字体大小。
        endFont (int): 目标字体大小。
    """
    self.startFont  = 0
    self.endFont  = 0

    def __init__(self, startFont, endont, durationTick, linear=False):
        # type: (int, int, int, bool) -> None
        """
        初始化FontSizeChangeTween类的新实例。

        Args:
            startFont (int): 起始字体大小。
            endFont (int): 目标字体大小。
            durationTick (int): 效果的持续时间（以帧为单位）。
            linear (bool): 动画速度匀速。 False时：动画速度是一开始很快，后面慢慢的
        """
        pass

class TextTween(Tween):
    # type: () -> None
    """
    Tween的子类，实现一长段文字逐渐显示的动画效果。

    Attributes:
        message (str): 消息内容。
    """
    self.message  = ""

    def __init__(self, message, durationTick, linear=False):
        # type: (str, int, bool) -> None
        """
        初始化TextTween类的新实例。

        Args:
            message (str): 消息内容。
            durationTick (int): 效果的持续时间（以帧为单位）。
            linear (bool): 动画速度匀速。 False时：动画速度是一开始很快，后面慢慢的
        """
        pass

class PosChangeTween(Tween):
    # type: () -> None
    """
    Tween的子类，实现位置变化的动画效果。

    Attributes:
        startPos (tuple): 起始位置（x, y元组）。
        endPos (tuple): 目标位置（x, y元组）。
        sine (bool): 是否使用正弦波效果。
    """
    self.startPos  = ()
    self.endPos  = ()
    self.sine  = False

    def __init__(self, startPos, endPos, durationTick, linear=False, sine=False):
        # type: (tuple, tuple, int, bool, bool, 可选) -> None
        """
        初始化PosChangeTween类的新实例。

        Args:
            startPos (tuple): 起始位置（x, y元组）。
            endPos (tuple): 目标位置（x, y元组）。
            durationTick (int): 效果的持续时间（以帧为单位）。
            linear (bool): 动画速度匀速。 False时：动画速度是一开始很快，后面慢慢的
            sine (bool, 可选): 是否使用正弦波效果，默认为False。
        """
        pass

class UVFrameTween(Tween):
    # type: () -> None
    """
    UVFrameTween类是Tween的子类，实现UV帧动画效果。

    Attributes:
        uvStep (tuple): UV步长。
        frameCount (int): 帧总数。
        durationTick (int): 效果的持续时间（以帧为单位）。
        maxFrame (int): 最大帧数，默认为None。
    """
    self.uvStep  = ()
    self.frameCount  = 0
    self.durationTick  = 0
    self.maxFrame  = 0

    def __init__(self, uvStep, frameCount, durationTick, maxFrame=None):
        # type: (tuple, int, int, int) -> None
        """
        初始化UVFrameTween类的新实例。

        Args:
            uvStep (tuple): UV步长。
            frameCount (int): 帧总数。
            durationTick (int): 效果的持续时间（以帧为单位）。
            maxFrame (int): 最大帧数，默认为None。
        """
        pass

class SizeChangeTween(Tween):
    # type: () -> None
    """
    SizeChangeTween类是Tween的子类，实现尺寸变化的动画效果。

    Attributes:
        startSize (tuple): 起始尺寸。
        endSize (tuple): 目标尺寸。
        accelarate (bool): 是否加速变化。
    """
    self.startSize  = ()
    self.endSize  = ()
    self.accelarate  = False

    def __init__(self, startSize, endSize, durationTick, accelarate=True):
        # type: (tuple, tuple, int, bool, 可选) -> None
        """
        初始化SizeChangeTween类的新实例。

        Args:
            startSize (tuple): 起始尺寸。
            endSize (tuple): 目标尺寸。
            durationTick (int): 效果的持续时间（以帧为单位）。
            accelarate (bool, 可选): 是否加速变化，默认为True。
        """
        pass

class ProgressBarTween(Tween):
    # type: () -> None
    """
    ProgressBarTween类是Tween的子类，实现进度条的百分比逐渐上升/下降的效果。

    Attributes:
        startPercent (float): 起始百分比。
        endPercent (float): 目标百分比。
        accelarate (bool): 是否加速变化。
    """
    self.startPercent  = 0.0
    self.endPercent  = 0.0
    self.accelarate  = False

    def __init__(self, startPercent, endPercent, durationTick, accelarate=True):
        # type: (float, float, int, bool, 可选) -> None
        """
        初始化ProgressBarTween类的新实例。

        Args:
            startPercent (float): 起始百分比。
            endPercent (float): 目标百分比。
            durationTick (int): 效果的持续时间（以帧为单位）。
            accelarate (bool, 可选): 是否加速变化，默认为True。
        """
        pass

